群论笔记 07

now functors can composable, and also identity, and also assoiative.

titter :)

functors can be a category!

In functor category*(or called category of functors) *functor are morphisms.

what is functor? he is mapping of categories. what is function? he is mapping of objects.

so, category is the object of functor category, so category in functor category has another name cat.

tail :: [a] -> [a] //not safe for empty list

[a] is like List[A] in scala

we now learned the functor category, so we can define a safeTail

safeTail :: [a]->Maybe[a]
safeTail [] = Nothing
safeTail (x: xs) = Just xs

note that: 1. [a] is functor; Maybe[a] is functor; 2. safeTail is a mapping of functors; 3. like functor is a mapping of categories, safeTail is a functor of functor categories

seriously, :| remember fmap? fmap is a mapping of functions; safeTail is a mapping of functors;

we may should try using fmap

fmap will always go inside of container(functor), and apply the operation on the inside things, and again put it back into the container.

seriously, :|

1. now I find that, haskell has a syntax type as lisp: all operator and function are prefix, damn it.
2. because function is list, and list is function. so in scala, we can apply fmap twin map to Collections, although the signiture of fmap is a mapping from function to function.

=haskell square on the Maybe

:: Maybe[Int] sq
:: Int -> Int fmap( fmap sq ) mis // same with (fmap . fmap)
sq mis // remeber that,
(a->b)->(Fa-Fb) => ((a->b)->Fa) -> Fb

note that

1. fmap sq is applying fmap to a function, you get a function >
2. fmap( famp sq ) is applying fmap to the function return from step(1), again get a function
3. funcion from step(2), takes mis as parameter, operate on inside value of mis getting another value, then put it back into the container.

this is how you compose the functors in haskell

we mentioned previous lecture that, almost all the type constructor in haskell will automatically be a functor, because regular data structure in haskell are algebraic data types, all these algebraic data types are automatically functorial. And algebraic data types have some operations like product(-type), sum(-type), exponential(-type).

so in algebraic datatypes' eyes, the Either/Option/Try/Future are same as + in algebraic, they are both operation so in algebraic datatypes' eyes, the collections are same as * in algebraic, they are both operation so in algebraic datatypes' eyes, the functions are same as ^ in algebraic, they are both operation

when you use these "operaion" on algebraic datatypes, you automatically get a functor, and a 1-to-1 relationship will build up:

(a,b) is a product-type, when can rewrite in another fomr (,) a b, and when we fix a ,is it a type constructor of b. Something like

type X = (,) a
X b

X now is a type constructor of b, a functor on b, a contrainer of b. Now we can apply function to b, by fmap, we just illustrate it:

of couse it could do ,and the related scala code is like: a reference to type constructor used in scala's function

Then you may think, we have product functor now, what about sum functor?

No worries, we can use the same principle of BiFunctor, apply to sum functor.

Either a b is a sum-type, but you should notice that we describe it by a BiFunctor manner.

Either a b takes a pair of types, OK pair of types is a product category, like we have find above. Instead of every object and arrow is tuple pair —

( * for object in product category: (,) a b * for arrow in product category: (,) f g

),

they should eigher pair —

( * for object in "eigther" category: eigher a b * for arrow in "eigther" category: eigher f g

),

in this sum-type scenario.

the ONLY difference is fmap, you must use a case clause to match one type or the other one.

here we have two kinds of functor: product-functor and sum-functor, they can be both decribed by C×C->C — BiFunctor form.

Actually in any category, if you have products defined for all pair of objects, like two: product-functor and sum-functor above, we have another name for that category: Cartesian Category

C × C -> C , BiFunctor , Cartesian Category.

And the same is true about the coproduct, coproduct is also a BiFunctor, long ago from now we defined coproduct just by the objects, but now we should define the coproduct also for morphism(arrow), just like what we do for product-functor above.

So, what we want to prove, I want to show that this is bifunctor I have to show that I can lift this pair (f,g) to something that there is a unique morphism between a × b and a' × b'. But how can I do this, if we compose f and p, compose q and g, we will find something familiar.

yes, a × b become one candidate of a' × b' with two projections a' and b'. So, there must be a unique morphism between the a × b and a' × b', we call this morphism f × g and this is "but now we should define the coproduct also for morphism(arrow)" — the coproduct lifting.

That is categorical product, not just only a pair, that's a cartesian category, it's a bifunctor, and if we have a coproduct in a category, we will have some co-Cartesian category. Then the coproduct is a bifunctor as well. So we have a category that has a bifunctor more general that just product or coproduct, maybe there are other bifunctors. So this kind of category have a bifunctor are called monoidal category , * bifunctor is like a binary operater. * for unit we will prove that next lecture.

titter :) , monoid again, you know, unit and associative

• Product category is C * D -> E
• but Product category in Haskell is just C * C -> C, — Haskell is ONE Category
• So this is the same(?) thing with two arguments type constructor
• Cartesian Category is another name of Product category
• Monoidal category is that we have a bifunctor(simply speeking, two arguments type constructor) like Map[/,/] on this Cartesian category.
• bifunctor of Monidal category is that binary operator of Monoid

we'll not introduce all things about monoidal category, it's too abstract.

In the monoidal category we would like to define things like what does it mean to multiply two objects.

product category is something like a way of multiplying objects, you have object a and object b, you multiply them and get the product.Now we have one part of a monoid — binary operation — bifuncotr.

• monoid is for set category
  • binary operation is for elements of object set, or elements of hom-set.
  • for production, unit is singleton set (), terminal object up to isomorphism.
• monoidal category is product category wih operater bifunctor.
  • you can prove unit from graphic below.
  • you also can find bifunctor.

it means like something F[A,Unit] = F[A] in scala.

I can do the same thing for coproduct, unit would be the initial object

What's the good name for this product that could be a coproduct or could be a bifunctor, it's called tensor product, So monoidal category has a tensor product. tesor product has a unit.